Ποια είναι η διαφορά μεταξύ «git pull» και «git fetch»;

1
2
Επόμενο
Με τους απλούστερους όρους, το git pull κάνει ένα git fetch ακολουθούμενο από ένα git merge.
Μπορείτε να κάνετε ανάκτηση git ανά πάσα στιγμή για να ενημερώσετε τους κλάδους απομακρυσμένης παρακολούθησης στις αναφορές / remotes /  /.
Αυτή η λειτουργία δεν αλλάζει ποτέ κανένα από τα δικά σας τοπικά υποκαταστήματα υπό αναφορές / κεφάλια και είναι ασφαλές να γίνει χωρίς να αλλάξετε το αντίγραφο εργασίας σας. Έχω ακούσει ακόμη και για άτομα που τρέχουν το git fetch περιοδικά σε μια εργασία cron στο παρασκήνιο (αν και δεν θα το συνιστούσα να το κάνω αυτό).
Το git pull είναι αυτό που θα κάνατε για να ενημερώσετε ένα τοπικό υποκατάστημα με την απομακρυσμένη του έκδοση, ενώ ταυτόχρονα θα ενημερώσετε τους άλλους κλάδους απομακρυσμένης παρακολούθησης.
Από την τεκμηρίωση του Git για το git pull:
Στην προεπιλεγμένη λειτουργία του, το git pull είναι στενό για git fetch ακολουθούμενο από το git merge FETCH_HEAD.
|
Όταν χρησιμοποιείτε το τράβηγμα, το Git προσπαθεί να κάνει αυτόματα τη δουλειά σας για εσάς. Είναι ευαίσθητο στο περιβάλλον, οπότε το Git θα συγχωνεύσει τυχόν δεσμευμένες δεσμεύσεις στον κλάδο στον οποίο εργάζεστε. Το pull συγχωνεύει αυτόματα τις δεσμεύσεις χωρίς να σας επιτρέπει να τις ελέγξετε πρώτα. Εάν δεν διαχειρίζεστε στενά τα υποκαταστήματα σας, ενδέχεται να αντιμετωπίσετε συχνές συγκρούσεις.
Όταν φέρετε, το Git συγκεντρώνει τυχόν δεσμεύσεις από τον κλάδο προορισμού που δεν υπάρχουν στον τρέχοντα κλάδο σας και τις αποθηκεύει στο τοπικό αποθετήριό σας. Ωστόσο, δεν τα συγχωνεύει με τον τρέχοντα κλάδο σας. Αυτό είναι ιδιαίτερα χρήσιμο εάν πρέπει να διατηρήσετε ενημερωμένο το αποθετήριο σας, αλλά εργάζεστε σε κάτι που μπορεί να σπάσει εάν ενημερώσετε τα αρχεία σας.
Για να ενσωματώσετε τις δεσμεύσεις στον κύριο κλάδο σας, χρησιμοποιείτε τη συγχώνευση.
|
Είναι σημαντικό να αντιπαραβάλλετε τη φιλοσοφία σχεδιασμού του git με τη φιλοσοφία ενός πιο παραδοσιακού εργαλείου ελέγχου πηγής όπως το SVN.
Το Subversion σχεδιάστηκε και δημιουργήθηκε με μοντέλο πελάτη / διακομιστή. Υπάρχει ένα μοναδικό αποθετήριο που είναι ο διακομιστής και πολλοί πελάτες μπορούν να πάρουν κώδικα από το διακομιστή, να τον επεξεργαστούν και να τον δεσμεύσουν ξανά στον διακομιστή. Η υπόθεση είναι ότι ο πελάτης μπορεί πάντα να επικοινωνήσει με τον διακομιστή όταν χρειάζεται να εκτελέσει μια λειτουργία.
Το Git σχεδιάστηκε για να υποστηρίζει ένα πιο κατανεμημένο μοντέλο χωρίς να χρειάζεται κεντρικό αποθετήριο (αν και μπορείτε σίγουρα να το χρησιμοποιήσετε αν θέλετε). Επίσης, το git σχεδιάστηκε έτσι ώστε ο πελάτης και ο "διακομιστής" να μην χρειάζεται να είναι συνδεδεμένοι ταυτόχρονα. Το Git σχεδιάστηκε έτσι ώστε τα άτομα σε έναν αναξιόπιστο σύνδεσμο να μπορούν να ανταλλάσσουν κώδικα μέσω email, ακόμη και. Είναι δυνατή η εργασία εντελώς αποσυνδεδεμένη και η εγγραφή ενός CD για την ανταλλαγή κώδικα μέσω git.
Για να υποστηρίξει αυτό το μοντέλο, το git διατηρεί ένα τοπικό αποθετήριο με τον κωδικό σας και επίσης ένα επιπλέον τοπικό αποθετήριο που αντικατοπτρίζει την κατάσταση του απομακρυσμένου αποθετηρίου. Διατηρώντας ένα αντίγραφο του απομακρυσμένου αποθετηρίου τοπικά, το git μπορεί να καταλάβει τις αλλαγές που απαιτούνται ακόμη και όταν το απομακρυσμένο αποθετήριο δεν είναι προσβάσιμο. Αργότερα όταν πρέπει να στείλετε τις αλλαγές σε κάποιον άλλο, το git μπορεί να τις μεταφέρει ως ένα σύνολο αλλαγών από ένα χρονικό σημείο που είναι γνωστό στο απομακρυσμένο αποθετήριο.
Το git fetch είναι η εντολή που λέει "ενημερώστε το τοπικό αντίγραφο του απομακρυσμένου αποθετηρίου."
Το git pull λέει "φέρνω τις αλλαγές στο απομακρυσμένο αποθετήριο στο σημείο όπου διατηρώ τον δικό μου κωδικό."
Κανονικά, το git pull το κάνει κάνοντας git fetch για να ενημερώσετε το τοπικό αντίγραφο του απομακρυσμένου αποθετηρίου και, στη συνέχεια, συγχωνεύοντας τις αλλαγές στο δικό σας αποθετήριο κώδικα και ενδεχομένως στο αντίγραφο εργασίας σας.
Η αφαίρεση είναι να θυμάστε ότι υπάρχουν συχνά τουλάχιστον τρία αντίγραφα ενός έργου στο σταθμό εργασίας σας. Ένα αντίγραφο είναι το δικό σας αποθετήριο με το δικό σας ιστορικό δεσμεύσεων. Το δεύτερο αντίγραφο είναι το αντίγραφο εργασίας σας όπου επεξεργάζεστε και δημιουργείτε. Το τρίτο αντίγραφο είναι το τοπικό "προσωρινά αποθηκευμένο" αντίγραφο ενός απομακρυσμένου αποθετηρίου.
|
Εδώ είναι η εικόνα του Oliver Steele για το πώς όλα αυτά ταιριάζουν:
Αν υπάρχει αρκετό ενδιαφέρον, υποθέτω ότι θα μπορούσα να ενημερώσω την εικόνα για να προσθέσω git clone και git merge ...
|
Μία περίπτωση χρήσης του git fetch είναι ότι τα ακόλουθα θα σας πουν οποιεσδήποτε αλλαγές στον απομακρυσμένο κλάδο από την τελευταία σας έλξη ... ώστε να μπορείτε να ελέγξετε πριν κάνετε μια πραγματική έλξη, η οποία θα μπορούσε να αλλάξει τα αρχεία στον τρέχοντα κλάδο και το αντίγραφο εργασίας σας.
σκατά
git diff ... προέλευση
Δείτε: https://git-scm.com/docs/git-diff σχετικά με τη σύνταξη διπλής και τριπλής κουκκίδας στην εντολή diff
|
Μου κόστισε λίγο για να καταλάβω ποια ήταν η διαφορά, αλλά αυτή είναι μια απλή εξήγηση. πλοίαρχος στο localhost σας είναι ένα υποκατάστημα.
Όταν κλωνοποιείτε ένα αποθετήριο, παίρνετε ολόκληρο το αποθετήριο στον τοπικό κεντρικό υπολογιστή σας. Αυτό σημαίνει ότι εκείνη τη στιγμή έχετε έναν δείκτη προέλευσης / κύριου για HEAD και master δείχνοντας τον ίδιο HEAD.
όταν αρχίσετε να εργάζεστε και δεσμεύεστε να προωθήσετε τον κύριο δείκτη στο HEAD + τις δεσμεύσεις σας. Αλλά ο δείκτης προέλευσης / κύριου δείκτη εξακολουθεί να δείχνει τι ήταν όταν κλωνοποιήσατε.
Έτσι η διαφορά θα είναι:
Εάν κάνετε μια ανάκτηση git, θα πάρει απλώς όλες τις αλλαγές στο απομακρυσμένο αποθετήριο (GitHub) και θα μετακινήσει τον αρχικό / κύριο δείκτη στο HEAD. Εν τω μεταξύ, ο τοπικός υπεύθυνος υποκαταστήματος θα συνεχίσει να δείχνει πού έχει.
Εάν κάνετε ένα τράβηγμα git, θα κάνει βασικά να πάρει (όπως εξηγείται προηγουμένως) και να συγχωνεύσει τυχόν νέες αλλαγές στοκύριο κλάδο και μετακινήστε το δείκτη στο HEAD.
|
Μερικές φορές βοηθά μια οπτική αναπαράσταση.
|
Εν ολίγοις
Το git fetch είναι παρόμοιο με το τράβηγμα αλλά δεν συγχωνεύεται. δηλ. λαμβάνει απομακρυσμένες ενημερώσεις (αναφορές και αντικείμενα) αλλά η τοπική σας παραμένει η ίδια (δηλαδή η προέλευση / ο κύριος ενημερώνεται αλλά ο κύριος παραμένει το ίδιο).
Το git pull τραβά προς τα κάτω από ένα τηλεχειριστήριο και συγχωνεύεται αμέσως.
Περισσότερο
git clone κλωνοποιεί ένα repo.
Το git rebase αποθηκεύει πράγματα από τον τρέχοντα κλάδο που δεν βρίσκεται στον ανάντη κλάδο σε μια προσωρινή περιοχή. Το υποκατάστημα σας είναι τώρα το ίδιο όπως πριν ξεκινήσετε τις αλλαγές σας. Έτσι, το git pull -rebase θα τραβήξει τις απομακρυσμένες αλλαγές, θα επαναφέρει το τοπικό σας υποκατάστημα, θα επαναλάβει τις αλλαγές σας πάνω από το πάνω μέρος του τρέχοντος κλάδου σας ένα προς ένα έως ότου είστε ενημερωμένοι.
Επίσης, το git branch -a θα σας δείξει ακριβώς τι συμβαίνει με όλα τα καταστήματά σας - τοπικά και απομακρυσμένα.
Αυτή η ανάρτηση ιστολογίου ήταν χρήσιμη:
Η διαφορά μεταξύ git pull, git fetch και git clone (και git rebase) - Mike Pearce
και καλύπτει git pull, git fetch, git clone και git rebase.
====
ΕΚΣΥΓΧΡΟΝΙΖΩ
Σκέφτηκα ότι θα το ενημερώσω για να δείξω πώς θα το χρησιμοποιούσατε στην πράξη.
Ενημερώστε το τοπικό σας repo από το τηλεχειριστήριο (αλλά μην συγχωνεύσετε):
σκατά
Μετά τη λήψη των ενημερώσεων, ας δούμε τις διαφορές:
git diff master προέλευση / master
Εάν είστε ικανοποιημένοι με αυτές τις ενημερώσεις, συγχωνεύστε:
τράβηγμα
Σημειώσεις:
Στο βήμα 2: Για περισσότερες διαφορές μεταξύ τοπικών και τηλεχειριστηρίων, δείτε: Πώς να συγκρίνετε έναν τοπικό κλάδο git με τον απομακρυσμένο κλάδο του;
Στο βήμα 3: Ίσως είναι πιο ακριβές (π.χ. σε ένα γρήγορο repo αλλαγής) να κάνετε μια προέλευση git rebase εδώ. Δείτε το σχόλιο @Justin Ohms σε άλλη απάντηση.
Δείτε επίσης: http://longair.net/blog/2009/04/16/git-fetch-and-merge/
|
git-pull - Λήψη και συγχώνευση με άλλο αποθετήριο ή τοπικό υποκατάστημα
ΣΥΝΟΨΗ
τράβηγμα
ΠΕΡΙΓΡΑΦΗ
Εκτελεί το git-fetch με τις δεδομένες παραμέτρους και καλεί το git-merge για συγχώνευση του
ανακτήθηκαν οι κεφαλές στον τρέχοντα κλάδο. Με το --rebase, καλεί το git-rebase
αντί για git-merge.
Σημειώστε ότι μπορείτε να χρησιμοποιήσετε. (τρέχων κατάλογος) ως  για να τραβήξετε
από το τοπικό αποθετήριο - αυτό είναι χρήσιμο κατά τη συγχώνευση τοπικών υποκαταστημάτων
στον τρέχοντα κλάδο.
Σημειώστε επίσης ότι οι επιλογές προορίζονται για το ίδιο το git-pull και το υποκείμενο git-merge
πρέπει να δοθούν πριν από τις επιλογές που προορίζονται για το git-fetch.
Θα τραβήξατε αν θέλετε τα ιστορικά να συγχωνευτούν, θα μπορούσατε να φέρετε αν απλώς «θέλετε το codez» καθώς κάποιο άτομο έχει επισημάνει κάποια άρθρα εδώ.
|
Μπορείτε να κάνετε λήψη από ένα απομακρυσμένο αποθετήριο, να δείτε τις διαφορές και, στη συνέχεια, να τραβήξετε ή να συγχωνεύσετε.
Αυτό είναι ένα παράδειγμα για ένα απομακρυσμένο αποθετήριο που ονομάζεται προέλευση και ένα υποκατάστημα που ονομάζεται κύρια παρακολούθηση της απομακρυσμένης προέλευσης / κύριου κλάδου:
git checkout master
σκατά
git diff origin / master
git rebase origin master
|
Η σύντομη και εύκολη απάντηση είναι ότι το git pull είναι απλά git fetch ακολουθούμενο από το git merge.
Είναι πολύ σημαντικό να σημειωθεί ότι το git pull θα συγχωνευτεί αυτόματα είτε σας αρέσει είτε όχι. Αυτό θα μπορούσε, φυσικά, να οδηγήσει σε συγχωνεύσεις. Ας υποθέσουμε ότι το τηλεχειριστήριό σας είναι προέλευσης και το υποκατάστημα σας είναι κύριο. Αν έχετε διαφορετική προέλευση / πλοίαρχο πριν τραβήξετε, θα πρέπει να έχετε κάποια ιδέα για πιθανές συγκρούσεις συγχώνευσης και θα μπορούσατε να προετοιμάσετε το τοπικό υποκατάστημα σας ανάλογα.
Εκτός από το τράβηγμα και την ώθηση, μερικές ροές εργασίας περιλαμβάνουν το git rebase, όπως αυτό, το οποίο παραφράζω από το συνδεδεμένο άρθρο:
git pull origin master
git checkout foo-υποκατάστημα
git rebase master
git push origin foo-κλάδος
Εάν βρεθείτε σε μια τέτοια κατάσταση, μπορεί να μπείτε στον πειρασμό να κάνετε git pull --rebase. Αν δεν γνωρίζετε πραγματικά τι κάνετε, θα το συνιστούσα. Αυτή η προειδοποίηση προέρχεται από την αρχική σελίδα για το git-pull, έκδοση 2.3.5:
Αυτός είναι ένας δυνητικά επικίνδυνος τρόπος λειτουργίας. Ξαναγράφει
ιστορικό, το οποίο δεν ταιριάζει καλά όταν δημοσιεύσατε αυτό το ιστορικό
ήδη. Μην χρησιμοποιείτε αυτήν την επιλογή εκτός εάν έχετε διαβάσει το git-rebase (1)
προσεκτικά.
|
Εντάξει, ακολουθούν ορισμένες πληροφορίες σχετικά με το git pull και το git fetch, ώστε να μπορείτε να κατανοήσετε τις πραγματικές διαφορές ... με λίγες απλές λέξεις, η λήψη λαμβάνει τα πιο πρόσφατα δεδομένα, αλλά δεν αλλάζει ο κώδικας και δεν πρόκειται να χάσει τον τρέχοντα τοπικό κωδικό υποκαταστήματος , αλλά τραβήξτε τις αλλαγές κώδικα και συγχωνεύστε τον με τον τοπικό σας κλάδο, διαβάστε για να λάβετε περισσότερες λεπτομέρειες για κάθε ένα:
σκατά
Θα κάνει λήψη όλων των αναφορών και αντικειμένων και τυχόν νέων κλάδων στο τοπικό αποθετήριο σας ...
Λήψη κλάδων ή / και ετικετών (συλλογικά, "αναφορές") από ένα ή περισσότερα
άλλα αποθετήρια, μαζί με τα απαραίτητα αντικείμενα για την ολοκλήρωσή τους
ιστορίες Οι κλάδοι απομακρυσμένης παρακολούθησης ενημερώνονται (δείτε την περιγραφή
παρακάτω για τρόπους ελέγχου αυτής της συμπεριφοράς).
Από προεπιλογή, κάθε ετικέτα που οδηγεί στο ιστορικό που λαμβάνεται είναι
έπαιρνε επίσης το αποτέλεσμα είναι η λήψη ετικετών που δείχνουν σε κλάδους που
σας ενδιαφέρει. Αυτή η προεπιλεγμένη συμπεριφορά μπορεί να αλλάξει χρησιμοποιώντας
τις επιλογές --tags ή --no-tags ή διαμορφώνοντας
απομακρυσμένο..tagOpt. Χρησιμοποιώντας ένα refspec που παίρνει ετικέτες ρητά,
μπορείτε να λάβετε ετικέτες που δεν οδηγούν σε κλάδους που σας ενδιαφέρουν
επίσης.
Το git fetch μπορεί να πάρειείτε ένα μεμονωμένο αποθετήριο ή διεύθυνση URL, ή
από πολλά αποθετήρια ταυτόχρονα εάν δοθεί και υπάρχει ένα
τηλεχειριστήρια. καταχώριση στο αρχείο διαμόρφωσης. (Δείτε το git-config1).
Όταν δεν έχει οριστεί τηλεχειριστήριο, από προεπιλογή το τηλεχειριστήριο προέλευσης θα είναι
χρησιμοποιείται, εκτός εάν έχει διαμορφωθεί ένας κλάδος ανάντη για το τρέχον
κλαδί.
Τα ονόματα των κωδικών που έχουν ληφθεί, μαζί με τα ονόματα των αντικειμένων
δείχνουν, γράφονται στο .git / FETCH_HEAD. Αυτές οι πληροφορίες μπορεί να είναι
χρησιμοποιείται από σενάρια ή άλλες εντολές git, όπως git-pull.
τράβηγμα
Θα εφαρμόσει τις αλλαγές από απομακρυσμένο στον τρέχοντα κλάδο σε τοπικό ...
Ενσωματώνει αλλαγές από ένα απομακρυσμένο αποθετήριο στον τρέχοντα κλάδο.
Στην προεπιλεγμένη λειτουργία του, το git pull είναι συντομογραφία για git fetch ακολουθούμενο από
git merge FETCH_HEAD.
Πιο συγκεκριμένα, το git pull τρέχει το git fetch με τις δεδομένες παραμέτρους και
καλεί το git merge για να συγχωνεύσει τις ανακτημένες κεφαλές κλάδου στο τρέχον
κλαδί. Με το --rebase, τρέχει το git rebase αντί του git merge.
θα πρέπει να είναι το όνομα ενός απομακρυσμένου αποθετηρίου όπως έχει περάσει
git-fetch1. μπορεί να ονομάσει ένα αυθαίρετο τηλεχειριστήριο (για παράδειγμα,
το όνομα μιας ετικέτας) ή ακόμη και μια συλλογή από αναφορές με αντίστοιχο
κλάδοι απομακρυσμένης παρακολούθησης (π.χ. refs / heads /: refs / remotes / origin /),
αλλά συνήθως είναι το όνομα ενός κλάδου στο απομακρυσμένο αποθετήριο.
Προεπιλεγμένες τιμές για και διαβάζονται από το
"Απομακρυσμένη" και "συγχώνευση" διαμόρφωση για τον τρέχοντα κλάδο, όπως ορίζεται από
git-branch - διαδρομή.
Δημιουργώ επίσης το παρακάτω οπτικό για να σας δείξω πώς δουλεύουν οι git fetch και git pull ...
|
Αυτή η διαδραστική γραφική αναπαράσταση είναι πολύ χρήσιμη στην υποδιαίρεση git: http://ndpsoftware.com/git-cheatsheet.html
git fetch απλώς "κατεβάζει" τις αλλαγές από το τηλεχειριστήριο στο τοπικό αποθετήριο. Το git pull κατεβάζει τις αλλαγές και τις συγχωνεύει στον τρέχοντα κλάδο σας. "Στην προεπιλεγμένη λειτουργία του, το git pull είναι συντομογραφία για git fetch ακολουθούμενο από το git merge FETCH_HEAD."
|
Δώρο:
Μιλώντας για το pull & fetch στις παραπάνω απαντήσεις, θα ήθελα να μοιραστώ ένα ενδιαφέρον κόλπο,
git pull - επαναφορά
Αυτή η παραπάνω εντολή είναι η πιο χρήσιμη εντολή στη ζωή μου που έσωσε πολύ χρόνο.
Πριν προωθήσετε τις νέες δεσμεύσεις σας στον διακομιστή, δοκιμάστε αυτήν την εντολή και θα συγχρονίσει αυτόματα τις πιο πρόσφατες αλλαγές διακομιστή (με μια λήψη + συγχώνευση) και θα τοποθετήσει την δέσμευσή σας στην κορυφή στο git log. Δεν χρειάζεται να ανησυχείτε για χειροκίνητη έλξη / συγχώνευση.
Βρείτε λεπτομέρειες στη διεύθυνση: http://gitolite.com/git-pull--rebase
|
Μου αρέσει να έχω κάποια οπτική αναπαράσταση της κατάστασης για να κατανοήσω αυτά τα πράγματα. Ίσως άλλοι προγραμματιστές θα ήθελαν επίσης να το δουν, οπότε εδώ είναι η προσθήκη μου. Δεν είμαι απόλυτα σίγουρος ότι όλα είναι σωστά, γι 'αυτό παρακαλώ σχολιάστε αν βρείτε λάθη.
ΤΟΠΙΚΟ ΣΥΣΤΗΜΑ
. ================================================== ===
=================. ================= =================== =============
ΑΠΟΚΑΤΑΣΤΑΣΗ ΑΠΟΘΗΚΕΥΣΗΣ. ΑΠΟΚΑΤΑΣΤΑΣΗ ΑΠΟΘΗΚΕΥΣΗΣ ΤΟΠΙΚΗΣ ΑΠΟΘΗΚΕΥΣΗΣ
(ΠΡΟΕΛΕΥΣΗ) (CACHED)
για παράδειγμα,      . καθρέφτης του
ένα repo github. . απομακρυσμένο repo
Μπορεί επίσης να είναι       .
πολλαπλά repo's.
.
.
FETCH * ------------------> *
Η τοπική σας προσωρινή μνήμη του τηλεχειριστηρίου ενημερώνεται με την προέλευση (ή πολλαπλή
εξωτερικές πηγές, που είναι κατανεμημένη φύση του git)
.
ΤΡΑΒΗΞΤΕ   *------------------------------------------------ --------> *
Οι αλλαγές συγχωνεύονται απευθείας στο τοπικό σας αντίγραφο. όταν συμβαίνουν συγκρούσεις,
σας ζητούνται αποφάσεις.
.
ΕΠΙΤΡΟΠΗ. * <--------------- *
Όταν προέρχεστε, για παράδειγμα, από την ανατροπή, μπορεί να πιστεύετε ότι πρόκειται για δέσμευση
θα ενημερώσει την προέλευση. Στο git, μια δέσμευση γίνεται μόνο στο τοπικό σας repo.
.
PUSH * <--------------------------------------- *
Συγχρονίζει τις αλλαγές σας πίσω στην προέλευση.
Μερικά σημαντικά πλεονεκτήματα για τη λήψη ενός καθρέφτη του τηλεχειριστηρίου είναι:
Απόδοση (μετακινηθείτε σε όλες τις δεσμεύσεις και τα μηνύματα χωρίς να προσπαθήσετε να το συμπιέσετε μέσω του δικτύου)
Σχόλια σχετικά με την κατάσταση του τοπικού σας repo (για παράδειγμα, χρησιμοποιώ το SourceTree της Atlassian, το οποίο θα μου δώσει έναν λαμπτήρα που θα υποδεικνύει αν δεσμεύομαι μπροστά ή πίσω σε σύγκριση με την προέλευση. Αυτές οι πληροφορίες μπορούν να ενημερωθούν με ένα GIT FETCH).
|
Έχω αγωνιστεί με αυτό επίσης. Στην πραγματικότητα έφτασα εδώ με μια αναζήτηση στο Google με την ίδια ακριβώς ερώτηση. Διαβάζοντας όλες αυτές τις απαντήσεις έβαλα τελικά μια εικόνα στο κεφάλι μου και αποφάσισα να προσπαθήσω να το κατεβάσω κοιτάζοντας την κατάσταση των 2 αποθετηρίων και 1 sandbox και τις ενέργειες που εκτελούνται με την πάροδο του χρόνου παρακολουθώντας την έκδοση αυτών. Εδώ λοιπόν είναι αυτό που βρήκα. Παρακαλώ διορθώστε με αν έκανα λάθος οπουδήποτε.
Τα τρία repos με μια ανάκτηση:
--------------------- ----------------------- ------ -----------------
- Remote Repo - - Remote Repo - - Remote Repo -
- - - ωθείται - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------------------------------
- Τοπικό Repo - - Τοπικό Repo - - Τοπικό Repo -
- τραβήξτε - - - - φέρετε -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Τοπικό Sandbox - - Τοπικό Sandbox - - Τοπικό Sandbox -
- Ταμείο - - νέα εργασία - - -
- @ R01 - - @ R01 + - - @ R01 + -
--------------------- ----------------------- ------ -----------------
Οι τρεις repos με ένα τράβηγμα
--------------------- ----------------------- ------ -----------------
- Remote Repo - - Remote Repo - - Remote Repo -
- - - ωθείται - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Τοπικό Repo - - Τοπικό Repo - - Τοπικό Repo -
- τραβήξτε - - - - τραβήξτε -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Τοπικό Sandbox - - Τοπικό Sandbox - - Τοπικό Sandbox -
- Ταμείο - - νέα εργασία - - συγχωνεύτηκε με R02 -
- @ R01 - - @ R01 + - - @ R02 + -
--------------------- ----------------------- ------ -----------------
Αυτό με βοήθησε να καταλάβω γιατί μια ανάκτηση είναι πολύ σημαντική.
|
Η διαφορά μεταξύ του GIT Fetch και του GIT Pull μπορεί να εξηγηθεί με το ακόλουθο σενάριο:
(Λάβετε υπόψη ότι οι εικόνες μιλούν πιο δυνατά από τις λέξεις !, Έχω παράσχει εικονογραφική αναπαράσταση)
Ας πάρουμε ένα παράδειγμα ότι εργάζεστε σε ένα έργο με τα μέλη της ομάδας σας. Θα υπάρχει λοιπόν ένας κύριος κλάδος του έργου και όλοι οι συντελεστές πρέπει να το πιέσουν στο δικό τους τοπικό αποθετήριο και, στη συνέχεια, να εργαστούν σε αυτό το τοπικό υποκατάστημα για να τροποποιήσουν / προσθέσουν ενότητες και, στη συνέχεια, να επιστρέψουν στον κύριο κλάδο.
Ετσι,
Η αρχική κατάσταση των δύο υποκαταστημάτων όταν διακλάδωσε το κύριο έργο στο τοπικό αποθετήριο θα είναι έτσι - (A, B και C είναι Ενότητες που έχουν ήδη ολοκληρωθεί του έργου)
Τώρα, έχετε ξεκινήσει να εργάζεστε στη νέα ενότητα (ας υποθέσουμε ότι το D) και όταν έχετε ολοκληρώσει τη μονάδα D θέλετε να την σπρώξετε στον κύριο κλάδο, αλλά εν τω μεταξύ αυτό που συμβαίνει είναι ότι ένας από τους συμπαίκτες σας έχει αναπτύξει νέα Module E, F και τροποποιημένο Γ.
Τώρα λοιπόν αυτό που έχει συμβεί είναι ότι το τοπικό αποθετήριό σας δεν βρίσκεται πίσω από την αρχική πρόοδο του έργου και, συνεπώς, η προώθηση των αλλαγών σας στον κύριο κλάδο μπορεί να οδηγήσει σε διένεξη και μπορεί να προκαλέσει δυσλειτουργία της ενότητας D σας.
Για την αποφυγή τέτοιων ζητημάτων και την παράλληλη εργασία με την αρχική πρόοδο του έργου, υπάρχουν δύο τρόποι:
1. Git Fetch- Αυτό θα κατεβάσει όλες τις αλλαγές που έχουν γίνει στο έργο προέλευσης / κύριου κλάδου που δεν υπάρχουν στο τοπικό σας κατάστημα. Και θα περιμένουμε την εντολή Git Merge να εφαρμόσει τις αλλαγές που έχουν ληφθεί στο αποθετήριο ή στον κλάδο σας.
Τώρα λοιπόν μπορείτε να παρακολουθείτε προσεκτικά τα αρχεία πριν τα συγχωνεύσετε στο αποθετήριο σας. Και μπορείτε επίσης να τροποποιήσετε το D εάν απαιτείται λόγω του Modified C.
2. Git Pull- Αυτό θα ενημερώσει τον τοπικό σας κλάδο με την προέλευση / τον κύριο κλάδο, δηλαδή στην πραγματικότητα αυτό που κάνει είναι ένας συνδυασμός των Git Fetch και Git συγχώνευση το ένα μετά το άλλο.
Ωστόσο, αυτό μπορεί να προκαλέσει την εμφάνιση συγκρούσεων, επομένως συνιστάται η χρήση του Git Pull με ένα καθαρό αντίγραφο.
|
Απλά λέμε:
git pull == git fetch + git συγχώνευση
Εάν εκτελείτε git pull, δεν χρειάζεται να συγχωνεύσετε τα δεδομένα σε τοπικό. Εάν εκτελείτε git fetch, αυτό σημαίνει ότι πρέπει να εκτελέσετε το git merge για να λάβετε τον πιο πρόσφατο κωδικό στο τοπικό σας μηχάνημα. Διαφορετικά, ο τοπικός κωδικός μηχανήματος δεν θα αλλάξει χωρίς συγχώνευση.
Έτσι στο Git Gui, όταν κάνετε λήψη, πρέπει να συγχωνεύσετε τα δεδομένα. Η λήψη από μόνη της δεν θα κάνει τον κώδικα αλλαγές στο τοπικό σας. Μπορείτε να το ελέγξετε κατά την ενημέρωση του κωδικού ανάκτησης
Μόλις φέρω και δες? ο κωδικός δεν θα αλλάξει. Τότε συγχωνεύεστε ... Θα δείτε τον αλλαγμένο κωδικό.
|
Το git fetch τραβάει τον κώδικα από τον απομακρυσμένο διακομιστή στους κλάδους παρακολούθησης στο τοπικό αποθετήριο. Εάν το τηλεχειριστήριό σας ονομάζεται προέλευση (η προεπιλογή), τότε αυτοί οι κλάδοι θα βρίσκονται εντός της προέλευσης /, για παράδειγμα προέλευσης / κύριας προέλευσης, προέλευσης / mybranch-123, κ.λπ. .
Το git pull κάνει git fetch αλλά συγχωνεύει επίσης τον κώδικα από τον κλάδο παρακολούθησης στο τρέχοντοπική έκδοση αυτού του κλάδου. Εάν δεν είστε ακόμη έτοιμοι για αυτές τις αλλαγές, απλώς πάρτε πρώτα.
|
Το git fetch θα ανακτήσει απομακρυσμένα κλαδιά, έτσι ώστε να μπορείτε να το git diff ή να το συγχωνεύσετε με το τρέχον κλαδί. Το git pull θα εκτελεστεί στο απομακρυσμένο brach που παρακολουθείται από τον τρέχοντα κλάδο και στη συνέχεια θα συγχωνεύσει το αποτέλεσμα. Μπορείτε να χρησιμοποιήσετε το git fetch για να δείτε εάν υπάρχουν ενημερώσεις στο απομακρυσμένο υποκατάστημα χωρίς να απαιτείται συγχώνευση με το τοπικό υποκατάστημα.
|
Git Fetch
Πραγματοποιείτε λήψη των αλλαγών στο τοπικό υποκατάστημα από την προέλευση μέσω λήψης. Το Fetch ζητά από το απομακρυσμένο repo για όλες τις δεσμεύσεις που έχουν κάνει άλλοι, αλλά δεν έχετε στο τοπικό σας repo. Λήψη λήψεων αυτών των δεσμεύσεων και προσθήκη τους στο τοπικό αποθετήριο.
Git Merge
Μπορείτε να εφαρμόσετε τις αλλαγές που κατεβάσατε μέσω της λήψης χρησιμοποιώντας την εντολή συγχώνευσης. Η συγχώνευση θα πάρει τις δεσμεύσεις που ανακτήθηκαν από τη λήψη και θα προσπαθήσει να τις προσθέσει στο τοπικό υποκατάστημα. Η συγχώνευση θα διατηρήσει το ιστορικό δεσμεύσεων των τοπικών αλλαγών σας, έτσι ώστε όταν μοιράζεστε το υποκατάστημα σας με το push, το Git θα γνωρίζει πώς άλλοι μπορούν να συγχωνεύσουν τις αλλαγές σας.
Git Pull
Η ανάκτηση και η συγχώνευση εκτελούνται μαζί αρκετά συχνά ώστε να δημιουργηθεί μια εντολή που συνδυάζει τα δύο, τραβήξτε. Το Pull κάνει fetch και έπειτα μια συγχώνευση για να προσθέσετε τις δεσμεύσεις που έχετε κατεβάσει στον τοπικό σας κλάδο.
|
Με απλά λόγια, εάν επρόκειτο να μεταβείτε σε ένα αεροπλάνο χωρίς καμία σύνδεση στο Διαδίκτυο ... πριν αναχωρήσετε, θα μπορούσατε απλά να κάνετε git fetch origin . Θα έφερνε όλες τις αλλαγές στον υπολογιστή σας, αλλά θα τον κρατούσε ξεχωριστό από την τοπική ανάπτυξη / χώρο εργασίας σας.
Στο αεροπλάνο, θα μπορούσατε να κάνετε αλλαγές στον τοπικό χώρο εργασίας σας και στη συνέχεια να τον συγχωνεύσετε με αυτό που έχετε πάρει και να επιλύσετε πιθανές συγκρούσεις συγχώνευσης χωρίς σύνδεση με το Διαδίκτυο. Και εκτός αν κάποιος είχε κάνει νέες αλλαγές στο απομακρυσμένο αποθετήριο, τότε μόλις φτάσετε στον προορισμό θα κάνατε git push origin  και πήγαινε να πάρετε τον καφέ σας.
Από αυτό το φοβερό σεμινάριο της Ατλασίας:
Η εντολή git fetch λήψεις δεσμεύει, αρχεία και αναφορές από ένα
απομακρυσμένο αποθετήριο στο τοπικό αποθετήριο.
Η λήψη είναι αυτό που κάνετε όταν θέλετε να δείτε τι έχουν όλοι οι άλλοι
δούλευα. Είναι παρόμοιο με την ενημέρωση SVN, καθώς σας επιτρέπει να δείτε
πώς έχει προχωρήσει η κεντρική ιστορία, αλλά δεν σας υποχρεώνει
πραγματικά συγχωνεύστε τις αλλαγές στο αποθετήριο σας. Το Git απομονώνει
ανέκτησε το περιεχόμενο από το υπάρχον τοπικό περιεχόμενο, έχει απολύτως
καμία επίδραση στο έργο τοπικής ανάπτυξης. Το ανακτημένο περιεχόμενο πρέπει να ελεγχθεί ρητά χρησιμοποιώντας την εντολή git checkout. Αυτό κάνει
ανάκτηση ενός ασφαλούς τρόπου ελέγχου των δεσμεύσεων προτού τα ενσωματώσετε
το τοπικό αποθετήριό σας.
Κατά τη λήψη περιεχομένου από απομακρυσμένο αποθετήριο, εντολές git pull και git fetch είναι διαθέσιμες για την ολοκλήρωση της εργασίας. Μπορείτε να σκεφτείτε
git πάρτε την «ασφαλή» έκδοση των δύο εντολών. Θα κατεβάσει
το απομακρυσμένο περιεχόμενο, αλλά να μην ενημερώσετε την κατάσταση λειτουργίας του τοπικού αποθετηρίου σας,
αφήνοντας άθικτη την τρέχουσα εργασία σας. Το git pull είναι το πιο επιθετικό
εναλλακτικά, θα κατεβάσει το απομακρυσμένο περιεχόμενο για το ενεργό τοπικό
διακλάδωση και εκτελέστε αμέσως το git merge για να δημιουργήσετε μια συγχώνευση
για το νέο απομακρυσμένο περιεχόμενο. Εάν έχετε εκκρεμεί αλλαγές σε εξέλιξη
Αυτό θα προκαλέσει συγκρούσεις και θα ξεκινήσει η συγχώνευση επίλυσης συγκρούσεων
ροή.
Με τράβηγμα git:
Δεν έχετε απομόνωση.
Δεν χρειάζεται να ελεγχθεί ρητά. Επειδή σιωπηρά συγχωνεύεται.
Το βήμα συγχώνευσης θα επηρεάσει την τοπική σας ανάπτυξη και ενδέχεται να προκαλέσει διενέξεις
Βασικά δεν είναι ασφαλές. Είναι επιθετικό.
Σε αντίθεση με το git fetch όπου επηρεάζει μόνο τα .git / refs / remotes, το git pull θα επηρεάσει τόσο το .git / refs / remotes όσο και το .git / refs / heads /
Χμμμ ... οπότε αν δεν ενημερώνω το αντίγραφο εργασίας με το git fetch, τότε που κάνω αλλαγές; Πού αποθηκεύει το Git fetch τις νέες δεσμεύσεις;
Μεγάλη ερώτηση. Το βάζει κάπου απομονωμένο από το αντίγραφο εργασίας σας. Αλλά και πάλι πού; Ας ανακαλύψουμε.
Στον κατάλογο του έργου σας (δηλαδή, όπου κάνετε τις εντολές σας git) κάντε:
είναι. Αυτό θα εμφανίσει τα αρχεία και τους καταλόγους. Τίποτα δροσερό, το ξέρω.
Τώρα κάνω ls -a. Αυτό θα εμφανίσει αρχεία κουκκίδων, δηλαδή αρχεία που ξεκινούν με. Στη συνέχεια, θα μπορείτε να δείτε έναν κατάλογο με το όνομα: .git.
Κάντε cd .git. Αυτό θα αλλάξει προφανώς τον κατάλογό σας.
Τώρα έρχεται το διασκεδαστικό μέρος. κάνω ls. Θα δείτε μια λίστα καταλόγων. Ψάχνουμε για refs. Κάντε cd refs.
Είναι ενδιαφέρον να δούμε τι υπάρχει σε όλους τους καταλόγους, αλλά ας επικεντρωθούμε σε δύο από αυτούς. κεφάλια και τηλεχειριστήρια. Χρησιμοποιήστε το cd για να ελέγξετε και μέσα τους.
Οποιαδήποτε ανάκτηση git θα κάνετε ενημέρωση στοιχείων στον κατάλογο /.git/refs/remotes. Δεν θα ενημερώσει τίποτα στον κατάλογο /.git/refs/heads.
Τυχόν git pull θα κάνει πρώτα το git fetch, θα ενημερώσει τα στοιχεία στον κατάλογο /.git/refs/remotes, έπειτα θα συγχωνευθεί με το τοπικό σας και μετά θα αλλάξει το κεφάλι μέσα στον κατάλογο /.git/refs/heads.
Μια πολύ καλή σχετική απάντηση μπορεί επίσης να βρεθεί στο πού βρίσκεται το "git fetch" ;.
Επίσης, αναζητήστε το "Slash notation" από τη δημοσίευση συμβάσεων ονομάτων κλάδων Git. Σας βοηθά να κατανοήσετε καλύτερα πώς το Git τοποθετεί τα πράγματαδιαφορετικούς καταλόγους.
Για να δείτε την πραγματική διαφορά
Απλά κάνε:
git fetch origin master
git checkout master
Εάν ενημερώθηκε το απομακρυσμένο κύριο θα λάβετε ένα μήνυμα σαν αυτό:
Το υποκατάστημα σας βρίσκεται πίσω από το "origin / master" κατά 2 δεσμεύσεις και μπορεί να προωθηθεί γρήγορα.
(χρησιμοποιήστε το "git pull" για να ενημερώσετε το τοπικό σας κατάστημα)
Αν δεν φέρεται και μόλις κάνατε το git checkout master, τότε το τοπικό σας git δεν θα γνώριζε ότι έχουν προστεθεί 2 δεσμεύσεις. Και θα έλεγε:
Ήδη στο "master"
Το υποκατάστημα σας είναι ενημερωμένο με το "origin / master".
Αλλά αυτό είναι ξεπερασμένο και λανθασμένο. Είναι επειδή το git θα σας δώσει ανατροφοδότηση αποκλειστικά βάσει όσων γνωρίζει. Είναι αδιανόητο για νέες δεσμεύσεις που δεν έχει υποχωρήσει ακόμα ...
Υπάρχει κάποιος τρόπος να δείτε τις νέες αλλαγές που έγιναν στο απομακρυσμένο ενώ εργάζεστε στο κατάστημα τοπικά;
Ορισμένα IDE (π.χ. Xcode) είναι εξαιρετικά έξυπνα και χρησιμοποιούν το αποτέλεσμα μιας ανάκτησης git και μπορούν να σχολιάσουν τις γραμμές κώδικα που έχουν αλλάξει στον απομακρυσμένο κλάδο του τρέχοντος κλάδου εργασίας σας. Εάν αυτή η γραμμή έχει αλλάξει τόσο από τις τοπικές αλλαγές όσο και από τον απομακρυσμένο κλάδο, τότε αυτή η γραμμή επισημαίνεται με κόκκινο. Δεν πρόκειται για σύγκρουση συγχώνευσης. Είναι μια πιθανή σύγκρουση συγχώνευσης. Είναι ένα headsup που μπορείτε να χρησιμοποιήσετε για να επιλύσετε τη μελλοντική σύγκρουση συγχώνευσης πριν κάνετε git pull από το απομακρυσμένο υποκατάστημα.
Διασκεδαστική συμβουλή:
Εάν ανακτήσατε έναν απομακρυσμένο κλάδο π.χ. έκανε:
git fetch origin feature / 123
Τότε αυτό θα πήγαινε στον κατάλογο των τηλεχειριστηρίων σας. Δεν είναι ακόμα διαθέσιμο στον τοπικό κατάλογό σας. Ωστόσο, απλοποιεί το ταμείο σας σε αυτό το απομακρυσμένο υποκατάστημα από το DWIM (Κάντε αυτό που εννοώ):
git checkout χαρακτηριστικό / 123
δεν χρειάζεται πλέον να κάνετε:
git checkout -b χαρακτηριστικό / 123 origin / feature / 123
Για περισσότερα σχετικά με αυτό διαβάστε εδώ
|
Η μόνη διαφορά μεταξύ του git pull και του git fetch είναι ότι:
Το git pull τραβάει από ένα μακρινό κλαδί και το συγχωνεύει.
Το git fetch παίρνει μόνο το απομακρυσμένο κλαδί αλλά δεν συγχωνεύεται
git pull = git fetch + git συγχώνευση ...
|
Το Git επιτρέπει την εφαρμογή χρονολογικά παλαιότερων δεσμεύσεων μετά από νεότερες δεσμεύσεις.
Εξαιτίας αυτού, η πράξη μεταφοράς δεσμεύσεων μεταξύ αποθετηρίων χωρίζεται σε δύο βήματα:
Αντιγραφή νέων δεσμεύσεων από απομακρυσμένο υποκατάστημα για αντιγραφή αυτού του απομακρυσμένου κλάδου μέσα σε τοπικό repo.
(λειτουργία repo to repo) master @ remote >> remote / origin / master @ local
Ενσωμάτωση νέων δεσμεύσεων στο τοπικό υποκατάστημα
(λειτουργία εντός-repo) απομακρυσμένο / origin / master @ local >> master @ local
Υπάρχουν δύο τρόποι για να κάνετε το βήμα 2. Μπορείτε:
Περάστε το τοπικό υποκατάστημα μετά από τον τελευταίο κοινό πρόγονο και προσθέστε νέες δεσμεύσεις παράλληλες με δεσμεύσεις που είναι μοναδικές στο τοπικό αποθετήριο, ολοκληρώνονται με τη συγχώνευση δέσμευσης, κλείνοντας το πιρούνι.
Εισαγάγετε νέες δεσμεύσεις μετά τον τελευταίο κοινό πρόγονο και εφαρμόστε ξανά δεσμεύσεις μοναδικές για το τοπικό αποθετήριο.
Στην ορολογία git, το βήμα 1 είναι το git fetch, το βήμα 2 είναι το git merge ή το git rebase
git pull είναι git fetch και git συγχώνευση
|
Το Git αποκτά τον κλάδο της τελευταίας έκδοσης από το τηλεχειριστήριο στο τοπικό χρησιμοποιώντας δύο εντολές:
git fetch: Το Git πρόκειται να πάρει την πιο πρόσφατη έκδοση από απομακρυσμένο σε τοπικό, αλλά δεν συγχωνεύεται αυτόματα.

git fetch origin master
git log -p master..origin / master
git merge origin / master
Οι παραπάνω εντολές σημαίνουν ότι κατεβάζετε την πιο πρόσφατη έκδοση του κύριου κλάδου από την προέλευση από το κεντρικό κλάδο απομακρυσμένου έως προέλευσης. Και στη συνέχεια συγκρίνει τον τοπικό κύριο κλάδο και τον κύριο κλάδο προέλευσης. Τέλος, συγχωνεύστε.
git pull: Το Git πρόκειται να πάρει την πιο πρόσφατη έκδοση από το τηλεχειριστήριο και να ενταχθεί στο τοπικό.

git pull origin master
Η παραπάνω εντολή είναι ισοδύναμη με το git fetch και το git merge. Στην πράξη, το git fetch μπορεί να είναι πιο ασφαλές γιατί πριν από τη συγχώνευση μπορούμε να δούμε τις αλλαγές και να αποφασίσουμε αν θα συγχωνευθούμε.
|
Ποια είναι η διαφορά μεταξύ του git pull και του git fetch;
Για να το καταλάβετε, πρέπει πρώτα να καταλάβετε ότι το τοπικό σας git διατηρεί όχι μόνο το τοπικό αποθετήριο σας, αλλά διατηρεί επίσης ένα τοπικό αντίγραφο του απομακρυσμένου αποθετηρίου.
Το git fetch ενημερώνει το τοπικό αντίγραφο του απομακρυσμένου αποθετηρίου. Για παράδειγμα, εάν το απομακρυσμένο αποθετήριο σας είναι GitHub - ίσως θελήσετε να ανακτήσετε τυχόν αλλαγές που έγιναν στο απομακρυσμένο αποθετήριο στο τοπικό αντίγραφο του απομακρυσμένου αποθετηρίου. Αυτό θα σας επιτρέψει να εκτελέσετε λειτουργίες όπως σύγκριση ή συγχώνευση.
Το git pull από την άλλη πλευρά θα μειώσει τις αλλαγές στο απομακρυσμένο αποθετήριο στο σημείο όπου διατηρείτε τον δικό σας κωδικό. Συνήθως, το git pull θα κάνει το git fetch πρώτα για να ενημερώσει το τοπικό αντίγραφο του απομακρυσμένου αποθετηρίου και, στη συνέχεια, θα συγχωνεύσει τις αλλαγές στο δικό σας αποθετήριο κώδικα και πιθανώς στο αντίγραφο εργασίας σας.
|
git pull == (git fetch + git συγχώνευση)
Το git fetch δεν αλλάζει σε τοπικά υποκαταστήματα.
Εάν έχετε ήδη ένα τοπικό αποθετήριο με ένα τηλεχειριστήριο για το επιθυμητό έργο, μπορείτε να τραβήξετε όλους τους κλάδους και τις ετικέτες για το υπάρχον τηλεχειριστήριο χρησιμοποιώντας git fetch ... Η ανάκτηση δεν πραγματοποιεί αλλαγές στα τοπικά υποκαταστήματα, επομένως θα πρέπει να συγχωνεύσετε έναν απομακρυσμένο κλάδο με έναν τοπικό κλάδο σε ζεύγη για να ενσωματώσετε νέες αλλαγές. από το github
|
Μια απλή γραφική αναπαράσταση για αρχάριους,
εδώ,
τράβηγμα
θα πάρει τον κωδικόαπό το αποθετήριο και το rebase με το τοπικό σας ... στο git pull υπάρχει δυνατότητα δημιουργίας νέων δεσμεύσεων.
αλλά σε ,
σκατά
θα ανακτήσει κώδικα από το αποθετήριο και πρέπει να τον αναδιαμορφώσουμε χειροκίνητα χρησιμοποιώντας το git rebase
π.χ.: πρόκειται να πάρω από τον κεντρικό υπολογιστή του διακομιστή και να το επανατοποθετήσω στο τοπικό μου κύριο.
1) git pull (η επαναφορά θα γίνει αυτόματα):
git pull origin master
εδώ η προέλευση είναι το απομακρυσμένο master repo σας είναι το υποκατάστημα σας
2) git fetch (ανάγκη χειροκίνητης επαναφοράς):
git fetch origin master
θα ανακτήσει αλλαγές διακομιστή από την προέλευση. και θα είναι στην περιοχή σας μέχρι να το επαναφέρετε μόνοι σας. πρέπει να διορθώσουμε τις διενέξεις χειροκίνητα ελέγχοντας τους κωδικούς.
git rebase origin / master
Αυτό θα επαναφέρει τον κώδικα σε τοπικό. πριν βεβαιωθείτε ότι είστε στο σωστό κλαδί.
|
Προσπαθώντας να είστε ξεκάθαροι και απλοί.
Η εντολή git pull είναι στην πραγματικότητα μια συντόμευση για git fetch ακολουθούμενη από το git merge ή την εντολή git rebase ανάλογα με τη διαμόρφωσή σας. Μπορείτε να διαμορφώσετε το αποθετήριο Git έτσι ώστε το git pull να είναι μια ανάκτηση ακολουθούμενη από μια επαναφορά.
|
Στην πραγματικότητα το Git διατηρεί ένα αντίγραφο του δικού σας κώδικα και
το απομακρυσμένο αποθετήριο.
Η εντολή git fetch ενημερώνει το τοπικό σας αντίγραφο λαμβάνοντας δεδομένα από απομακρυσμένο αποθετήριο. Ο λόγος που το χρειαζόμαστε είναι επειδή κάποιος άλλος μπορεί να έχει κάνει κάποιες αλλαγές στον κώδικα και θέλετε να ενημερώνεστε.
Η εντολή git pull φέρνει τις αλλαγές στο απομακρυσμένο αποθετήριο στο σημείο όπου διατηρείτε τον δικό σας κωδικό. Κανονικά, το git pull το κάνει αυτό κάνοντας ένα «git fetch» ​​πρώτα για να ενημερώσει το τοπικό αντίγραφο του απομακρυσμένου χώρου αποθήκευσης και στη συνέχεια συγχωνεύει τις αλλαγές στο δικό σας αποθετήριο κώδικα και πιθανώς στο αντίγραφο εργασίας σας.
|
1
2
Επόμενο
Πολύ ενεργή ερώτηση. Κερδίστε 10 φήμη για να απαντήσετε σε αυτήν την ερώτηση. Η απαίτηση φήμης συμβάλλει στην προστασία αυτής της ερώτησης από ανεπιθύμητες ενέργειες και μη απαντήσεις.
Δεν είναι η απάντηση που ψάχνετε; Περιηγηθείτε σε άλλες ερωτήσεις με ετικέτα git version-control git-pull git-fetch ή κάντε τη δική σας ερώτηση.